home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / clear.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  10.7 KB  |  451 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. /* undefine any macros for functions defined in this module */
  24. #undef    clear
  25. #undef    wclear
  26. #undef    erase
  27. #undef    werase
  28. #undef    clrtobot
  29. #undef    wclrtobot
  30. #undef    clrtoeol
  31. #undef    wclrtoeol
  32.  
  33. /* undefine any macros for functions called by this module if in debug mode */
  34. #ifdef PDCDEBUG
  35. #  undef    clearok
  36. #endif
  37.  
  38. #ifdef PDCDEBUG
  39. char *rcsid_clear  = "$Id$";
  40. #endif
  41.  
  42. /*man-start*********************************************************************
  43.  
  44.   Name:                                                         clear
  45.  
  46.   Synopsis:
  47.       int clear(void);
  48.       int wclear(WINDOW *win);
  49.       int erase(void);
  50.       int werase(WINDOW *win);
  51.       int clrtobot(void);
  52.       int wclrtobot(WINDOW *win);
  53.       int clrtoeol(void);
  54.       int wclrtoeol(WINDOW *win);
  55.  
  56.   X/Open Description:
  57.       The erase() and werase() functions copy blanks to every position
  58.       of the window.
  59.  
  60.       The clear() and wclear() functions are similar to erase() and
  61.       werase() except they also call clearok() to ensure that the
  62.       the screen is cleared on the next call to wrefresh() for that
  63.       window.
  64.  
  65.       The clrtobot() and wclrtobot() functions clear the screen from
  66.       the current cursor position to the end of the current line and
  67.       all remaining lines in the window.
  68.  
  69.       The clrtoeol() and wclrtoeol() functions clear the screen from
  70.       the current cursor position to the end of the current line only.
  71.  
  72.      NOTE: clear(), wclear(), erase(), clrtobot(), and clrtoeol()
  73.      are implemented as macros
  74.  
  75.   PDCurses Description:
  76.  
  77.   X/Open Return Value:
  78.      All functions return OK on success and ERR on error.
  79.  
  80.   X/Open Errors:
  81.      No errors are defined for this function.
  82.  
  83.   NOTE:
  84.      The behaviour of Unix curses is to clear the line with a space
  85.      and attributes of A_NORMAL. PDCurses clears the line with the
  86.      window's current attributes (including current colour). To get
  87.      the behaviour of PDCurses, #define ODCURSES_WCLR in curses.h or
  88.      add -DPDCURSES_WCLR to the compile switches.
  89.  
  90.   Portability                             X/Open    BSD    SYS V
  91.                                           Dec '88
  92.       clear                                 Y        Y       Y
  93.       wclear                                Y        Y       Y
  94.       erase                                 Y        Y       Y
  95.       werase                                Y        Y       Y
  96.       clrtobot                              Y        Y       Y
  97.       wclrtobot                             Y        Y       Y
  98.       clrtoeol                              Y        Y       Y
  99.       wclrtoeol                             Y        Y       Y
  100.  
  101. **man-end**********************************************************************/
  102.  
  103. /***********************************************************************/
  104. int    clear(void)
  105. /***********************************************************************/
  106. {
  107. #ifdef PDCDEBUG
  108.     if (trace_on) PDC_debug("clear() - called\n");
  109. #endif
  110.  
  111.     if  (stdscr == (WINDOW *)NULL)
  112.         return(ERR);
  113.  
  114.     clearok(stdscr, TRUE);
  115.     return(erase());
  116. }
  117. /***********************************************************************/
  118. int    wclear( WINDOW *win )
  119. /***********************************************************************/
  120. {
  121. #ifdef PDCDEBUG
  122.     if (trace_on) PDC_debug("wclear() - called\n");
  123. #endif
  124.  
  125.     if  (win == (WINDOW *)NULL)
  126.         return( ERR );
  127.  
  128.     clearok( win, TRUE );
  129.     return( werase( win ) );
  130. }
  131. /***********************************************************************/
  132. int    erase(void)
  133. /***********************************************************************/
  134. {
  135.     chtype*    end;
  136.     chtype*    start;
  137.     int    y,x;
  138.     chtype    blank;
  139.  
  140. #ifdef PDCDEBUG
  141.     if (trace_on) PDC_debug("erase() - called\n");
  142. #endif
  143.  
  144.     if (stdscr == (WINDOW *)NULL)
  145.         return( ERR );
  146.  
  147. #if defined(PDCURSES_WCLR)
  148.     blank    = stdscr->_blank | stdscr->_attrs;
  149. #else
  150. /* wrs (4/10/93) account for window background */
  151.     blank    = stdscr->_bkgd;
  152. #endif
  153.  
  154.     for (y = stdscr->_tmarg; y <= stdscr->_bmarg; y++)
  155.     {
  156.         start = stdscr->_y[y];
  157.         end = &start[stdscr->_maxx - 1];
  158. /* changed JGB 6/92 < to <= */
  159.         while (start <= end)
  160.         {
  161.             *start++ = blank;
  162.         }
  163.         stdscr->_firstch[y] = 0;
  164.         stdscr->_lastch[y] = stdscr->_maxx - 1;
  165.     }
  166.     stdscr->_cury = stdscr->_tmarg;
  167.     stdscr->_curx = 0;
  168.  
  169.     return( OK );
  170. }
  171. /***********************************************************************/
  172. int    werase(WINDOW *win)
  173. /***********************************************************************/
  174. {
  175.     chtype*    end;
  176.     chtype*    start;
  177.     int    y,x;
  178.     chtype    blank;
  179.  
  180. #ifdef PDCDEBUG
  181.     if (trace_on) PDC_debug("werase() - called\n");
  182. #endif
  183.  
  184.     if (win == (WINDOW *)NULL)
  185.         return( ERR );
  186.  
  187. #if defined(PDCURSES_WCLR)
  188.     blank    = win->_blank | win->_attrs;
  189. #else
  190. /* wrs (4/10/93) account for window background */
  191.     blank    = win->_bkgd;
  192. #endif
  193.  
  194.     for (y = win->_tmarg; y <= win->_bmarg; y++)
  195.     {
  196.         start = win->_y[y];
  197.         end = &start[win->_maxx - 1];
  198. /* changed JGB 6/92 < to <= */
  199.         while (start <= end)
  200.         {
  201.             *start++ = blank;
  202.         }
  203.         win->_firstch[y] = 0;
  204.         win->_lastch[y] = win->_maxx - 1;
  205.     }
  206.     win->_cury = win->_tmarg;
  207.     win->_curx = 0;
  208.  
  209.     return( OK );
  210. }
  211. /***********************************************************************/
  212. int    clrtobot(void)
  213. /***********************************************************************/
  214. {
  215.     int    y;
  216.     int    minx;
  217.     int    startx;
  218.     chtype    blank;
  219.     chtype*    ptr;
  220.     chtype*    end;
  221.     chtype*    maxx;
  222.  
  223. #ifdef PDCDEBUG
  224.     if (trace_on) PDC_debug("clrtobot() - called\n");
  225. #endif
  226.  
  227.     if  (stdscr == (WINDOW *)NULL)
  228.         return( ERR );
  229.  
  230. #if defined(PDCURSES_WCLR)
  231.     blank    = stdscr->_blank | stdscr->_attrs;
  232. #else
  233. /* wrs (4/10/93) account for window background */
  234.     blank    = stdscr->_bkgd;
  235. #endif
  236.  
  237.     startx    = stdscr->_curx;
  238.  
  239.     for (y = stdscr->_cury; y < stdscr->_maxy; y++)
  240.     {
  241.         minx    = _NO_CHANGE;
  242.         end    = &stdscr->_y[y][stdscr->_maxx - 1];
  243.         for (ptr = &stdscr->_y[y][startx]; ptr <= end; ptr++)
  244.         {
  245.             if (*ptr != blank)
  246.             {
  247.                 maxx = ptr;
  248.                 if (minx == _NO_CHANGE)
  249.                 {
  250.                     minx = (int) (ptr - stdscr->_y[y]);
  251.                 }
  252.                 *ptr = blank;
  253.             }
  254.         }
  255.         if (minx != _NO_CHANGE)
  256.         {
  257.             if ((stdscr->_firstch[y] > minx) ||
  258.                 (stdscr->_firstch[y] == _NO_CHANGE))
  259.             {
  260.                 stdscr->_firstch[y] = minx;
  261.                 if (stdscr->_lastch[y] < maxx - stdscr->_y[y])
  262.                 {
  263.                     stdscr->_lastch[y] = (int) (maxx - stdscr->_y[y]);
  264.                 }
  265.             }
  266.         }
  267.         startx = 0;
  268.     }
  269.     return( OK );
  270. }
  271. /***********************************************************************/
  272. int    wclrtobot(WINDOW *win)
  273. /***********************************************************************/
  274. {
  275.     int    y;
  276.     int    minx;
  277.     int    startx;
  278.     chtype    blank;
  279.     chtype*    ptr;
  280.     chtype*    end;
  281.     chtype*    maxx;
  282.  
  283. #ifdef PDCDEBUG
  284.     if (trace_on) PDC_debug("wclrtobot() - called\n");
  285. #endif
  286.  
  287.     if  (win == (WINDOW *)NULL)
  288.         return( ERR );
  289.  
  290. #if defined(PDCURSES_WCLR)
  291.     blank    = win->_blank | win->_attrs;
  292. #else
  293. /* wrs (4/10/93) account for window background */
  294.     blank    = win->_bkgd;
  295. #endif
  296.  
  297.     startx    = win->_curx;
  298.  
  299.     for (y = win->_cury; y < win->_maxy; y++)
  300.     {
  301.         minx    = _NO_CHANGE;
  302.         end    = &win->_y[y][win->_maxx - 1];
  303.         for (ptr = &win->_y[y][startx]; ptr <= end; ptr++)
  304.         {
  305.             if (*ptr != blank)
  306.             {
  307.                 maxx = ptr;
  308.                 if (minx == _NO_CHANGE)
  309.                 {
  310.                     minx = (int) (ptr - win->_y[y]);
  311.                 }
  312.                 *ptr = blank;
  313.             }
  314.         }
  315.         if (minx != _NO_CHANGE)
  316.         {
  317.             if ((win->_firstch[y] > minx) ||
  318.                 (win->_firstch[y] == _NO_CHANGE))
  319.             {
  320.                 win->_firstch[y] = minx;
  321.                 if (win->_lastch[y] < maxx - win->_y[y])
  322.                 {
  323.                     win->_lastch[y] = (int) (maxx - win->_y[y]);
  324.                 }
  325.             }
  326.         }
  327.         startx = 0;
  328.     }
  329.     return( OK );
  330. }
  331. /***********************************************************************/
  332. int    clrtoeol(void)
  333. /***********************************************************************/
  334. {
  335.     int    y;
  336.     int    x;
  337.     int    minx;
  338.     chtype    blank;
  339.     chtype*    maxx;
  340.     chtype*    ptr;
  341.     chtype*    end;
  342.  
  343. #ifdef PDCDEBUG
  344.     if (trace_on) PDC_debug("clrtoeol() - called\n");
  345. #endif
  346.  
  347.     if (stdscr == (WINDOW *)NULL)
  348.         return( ERR );
  349.  
  350.     y    = stdscr->_cury;
  351.     x    = stdscr->_curx;
  352.  
  353. #if defined(PDCURSES_WCLR)
  354.     blank    = stdscr->_blank | stdscr->_attrs;
  355. #else
  356. /* wrs (4/10/93) account for window background */
  357.     blank    = stdscr->_bkgd;
  358. #endif
  359.  
  360.     end    = &stdscr->_y[y][stdscr->_maxx - 1];
  361.     minx    = _NO_CHANGE;
  362.     maxx    = &stdscr->_y[y][x];
  363.  
  364.     for (ptr = maxx; ptr <= end; ptr++)
  365.     {
  366.         if (*ptr != blank)
  367.         {
  368.             maxx = ptr;
  369.             if (minx == _NO_CHANGE)
  370.             {
  371.                 minx = (int) (ptr - stdscr->_y[y]);
  372.             }
  373.             *ptr = blank;
  374.         }
  375.     }
  376.  
  377.     if (minx != _NO_CHANGE)
  378.     {
  379.         if ((stdscr->_firstch[y] > minx) ||
  380.             (stdscr->_firstch[y] == _NO_CHANGE))
  381.         {
  382.             stdscr->_firstch[y] = minx;
  383.         }
  384.         if (stdscr->_lastch[y] < maxx - stdscr->_y[y])
  385.         {
  386.             stdscr->_lastch[y] = (int) (maxx - stdscr->_y[y]);
  387.         }
  388.     }
  389.     return( OK );
  390. }
  391. /***********************************************************************/
  392. int    wclrtoeol(WINDOW *win)
  393. /***********************************************************************/
  394. {
  395.     int    y;
  396.     int    x;
  397.     int    minx;
  398.     chtype    blank;
  399.     chtype*    maxx;
  400.     chtype*    ptr;
  401.     chtype*    end;
  402.  
  403. #ifdef PDCDEBUG
  404.     if (trace_on) PDC_debug("wclrtoeol() - called\n");
  405. #endif
  406.  
  407.     if (win == (WINDOW *)NULL)
  408.         return( ERR );
  409.  
  410.     y    = win->_cury;
  411.     x    = win->_curx;
  412.  
  413. #if defined(PDCURSES_WCLR)
  414.     blank    = win->_blank | win->_attrs;
  415. #else
  416. /* wrs (4/10/93) account for window background */
  417.     blank    = win->_bkgd;
  418. #endif
  419.  
  420.     end    = &win->_y[y][win->_maxx - 1];
  421.     minx    = _NO_CHANGE;
  422.     maxx    = &win->_y[y][x];
  423.  
  424.     for (ptr = maxx; ptr <= end; ptr++)
  425.     {
  426.         if (*ptr != blank)
  427.         {
  428.             maxx = ptr;
  429.             if (minx == _NO_CHANGE)
  430.             {
  431.                 minx = (int) (ptr - win->_y[y]);
  432.             }
  433.             *ptr = blank;
  434.         }
  435.     }
  436.  
  437.     if (minx != _NO_CHANGE)
  438.     {
  439.         if ((win->_firstch[y] > minx) ||
  440.             (win->_firstch[y] == _NO_CHANGE))
  441.         {
  442.             win->_firstch[y] = minx;
  443.         }
  444.         if (win->_lastch[y] < maxx - win->_y[y])
  445.         {
  446.             win->_lastch[y] = (int) (maxx - win->_y[y]);
  447.         }
  448.     }
  449.     return( OK );
  450. }
  451.